#include <stdio.h>
#include <stdbool.h>

#define MaxSize 10 // 共享栈的总容量

typedef struct
{
    int data[MaxSize]; // 静态数组存储栈元素
    int top1;          // 栈1的栈顶指针
    int top2;          // 栈2的栈顶指针
} SharedStack;

// 1. 初始化共享栈
void InitStack(SharedStack &S)
{
    S.top1 = -1;      // 栈1初始指针（从数组头部开始）
    S.top2 = MaxSize; // 栈2初始指针（从数组尾部开始）
}

// 2. 销毁共享栈（顺序栈无需特殊销毁操作）
void DestroyStack(SharedStack &S)
{
    S.top1 = -1;
    S.top2 = MaxSize;
}

// 3. 压栈操作（stackNum指定是哪个栈）
bool Push(SharedStack &S, int stackNum, int x)
{
    if (S.top1 + 1 == S.top2)
    { // 栈满判断
        printf("SharedStack is full!\n");
        return false;
    }

    if (stackNum == 1)
    {
        S.data[++S.top1] = x; // 栈1指针右移
    }
    else if (stackNum == 2)
    {
        S.data[--S.top2] = x; // 栈2指针左移
    }
    else
    {
        printf("Invalid stack number!\n");
        return false;
    }
    return true;
}

// 4. 出栈操作（stackNum指定是哪个栈）
bool Pop(SharedStack &S, int stackNum, int &x)
{
    if (stackNum == 1)
    {
        if (S.top1 == -1)
        { // 栈1空判断
            printf("Stack1 is empty!\n");
            return false;
        }
        x = S.data[S.top1--]; // 栈1指针左移
    }
    else if (stackNum == 2)
    {
        if (S.top2 == MaxSize)
        { // 栈2空判断
            printf("Stack2 is empty!\n");
            return false;
        }
        x = S.data[S.top2++]; // 栈2指针右移
    }
    else
    {
        printf("Invalid stack number!\n");
        return false;
    }
    return true;
}

// 5. 获取栈顶元素（stackNum指定是哪个栈）
bool GetTop(SharedStack S, int stackNum, int &x)
{
    if (stackNum == 1)
    {
        if (S.top1 == -1)
        {
            printf("Stack1 is empty!\n");
            return false;
        }
        x = S.data[S.top1];
    }
    else if (stackNum == 2)
    {
        if (S.top2 == MaxSize)
        {
            printf("Stack2 is empty!\n");
            return false;
        }
        x = S.data[S.top2];
    }
    else
    {
        printf("Invalid stack number!\n");
        return false;
    }
    return true;
}

// 6. 获取栈底元素（stackNum指定是哪个栈）
bool GetBottom(SharedStack S, int stackNum, int &x)
{
    if (stackNum == 1)
    {
        if (S.top1 == -1)
        {
            printf("Stack1 is empty!\n");
            return false;
        }
        x = S.data[0]; // 栈1的栈底是数组第一个元素
    }
    else if (stackNum == 2)
    {
        if (S.top2 == MaxSize)
        {
            printf("Stack2 is empty!\n");
            return false;
        }
        x = S.data[MaxSize - 1]; // 栈2的栈底是数组最后一个元素
    }
    else
    {
        printf("Invalid stack number!\n");
        return false;
    }
    return true;
}

// 打印共享栈内容
void PrintStack(SharedStack S)
{
    printf("Stack1 [bottom->top]: ");
    for (int i = 0; i <= S.top1; i++)
    {
        printf("%d ", S.data[i]);
    }
    printf("\n");

    printf("Stack2 [bottom->top]: ");
    for (int i = MaxSize - 1; i >= S.top2; i--)
    {
        printf("%d ", S.data[i]);
    }
    printf("\n");
}

int main()
{
    SharedStack S;
    InitStack(S); // 初始化共享栈

    // 压栈操作
    Push(S, 1, 10); // 栈1压入10
    Push(S, 1, 20); // 栈1压入20
    Push(S, 2, 30); // 栈2压入30
    Push(S, 2, 40); // 栈2压入40
    PrintStack(S);
    /* 输出：
       Stack1 [bottom->top]: 10 20
       Stack2 [bottom->top]: 40 30
    */

    // 获取栈顶和栈底
    int top1, bottom1, top2, bottom2;
    GetTop(S, 1, top1);
    GetBottom(S, 1, bottom1);
    GetTop(S, 2, top2);
    GetBottom(S, 2, bottom2);
    printf("Stack1 - Top: %d, Bottom: %d\n", top1, bottom1); // Top: 20, Bottom: 10
    printf("Stack2 - Top: %d, Bottom: %d\n", top2, bottom2); // Top: 40, Bottom: 30

    // 出栈操作
    int popped1, popped2;
    Pop(S, 1, popped1);
    Pop(S, 2, popped2);
    printf("Popped from Stack1: %d\n", popped1); // 20
    printf("Popped from Stack2: %d\n", popped2); // 40
    PrintStack(S);
    /* 输出：
       Stack1 [bottom->top]: 10
       Stack2 [bottom->top]: 30
    */

    // 栈满测试
    printf("Testing stack full:\n");
    for (int i = 0; i < MaxSize + 2; i++)
    {
        if (!Push(S, 1, i))
            break;
    }

    // 栈空测试
    printf("Testing stack empty:\n");
    while (Pop(S, 1, popped1))
    {
        printf("Popped from Stack1: %d\n", popped1);
    }

    DestroyStack(S); // 销毁共享栈
    return 0;
}